#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>

using namespace std;

//class Date
//{
//public:
//	//explicit修饰构造函数，禁止隐式类型转化
//	//explicit Date(int year)
//	Date(int year)
//
//		:_year(year)
//	{
//		cout << "Date(int year)" << endl;
//	}
//
//	Date(const Date& d)
//	{
//		cout << "Date(const Date& d)" << endl;
//	}
//	~Date()
//	{
//		cout << "~Date()" << endl;
//	}
//private:
//	int _year;
//};
//
//int main()
//{
//	Date d1(2022);	//直接调用构造
//	Date d2 = 2022;	//隐式类型转化：构造+拷贝构造+编译器优化->直接调用构造
//	//Date& d3 = 2023;
//	cout << endl;
//	Date(2024);
//	cout << endl;
//	const Date& d4 = 2023;
//	return 0;
//}

//class A
//{
//public:
//	A() { ++_scount; }
//	A(const A& t) { ++_scount; }
//	~A() { --_scount; }
//	static int GetACount() { return _scount; }
//	/*static int Get_a()
//	{
//		_a = 1;
//	}*/
//private:
//	static int _scount;
//	int _a;
//};
//int A::_scount = 0;
//
//void TestA()
//{
//	cout << A::GetACount() << endl;
//	A a1, a2;
//	A a3(a1);
//	cout << A::GetACount() << endl;
//}
//int main()
//{
//	TestA();
//	return 0;
//}

//// 内部类
//class A
//{
//private:
//	int _h;
//	static int k;
//public:
//	// B定义在A的里面
//	// 1、受A的类域限制，访问限定符
//	// 2、B天生是A的友元
//	class B
//	{
//	public:
//		void foo(const A& a)
//		{
//			cout << k << endl;//OK——直接可以访问A的static成员
//			cout << a._h << endl;//OK -- 友元
//		}
//	private:
//		int _b;
//	};
//};
//int A::k = 1;
//
//int main()
//{
//	cout << sizeof(A) << endl; // 4——大小与内部类没关系，为sizeof(外部类）
//	A a;
//	A::B b;	//受A的类域限制
//
//	return 0;
//}

//class W
//{
//public:
//	W(int x = 0)
//	{
//		cout << "W()" << endl;
//	}
//
//	W(const W& w)
//	{
//		cout << "W(const W& w)" << endl;
//	}
//
//	W& operator=(const W& w)
//	{
//		cout << "W& operator=(const W& w)" << endl;
//		return *this;
//	}
//
//	~W()
//	{
//		cout << "~W()" << endl;
//	}
//};
//
//void f1(W w)
//{
//
//}
//
//void f2(const W& w)
//{
//
//}
//
////int main()
////{
////	W w1;
////	f1(w1);
////	f2(w1);
////	cout << endl << endl;
////
////	f1(W()); // 本来构造+拷贝构造--编译器的优化--直接构造
////	// 结论：连续一个表达式步骤中，连续构造一般都会优化 -- 合二为一
////
////	W w2 = 1;
////
////	return 0;
////}
//
//W f3()
//{
//	W ret;
//	return ret;
//}
//
//// 《深度探索C++对象模型》
//int main()
//{
//	f3(); // 1次构造  1次拷贝
//	cout << endl << endl;
//
//	W w1 = f3(); // 本来：1次构造  2次拷贝 -- 优化：1次构造  1次拷贝
//
//	cout << endl << endl;
//
//	W w2;
//	w2 = f3(); // 本来：1次构造  1次拷贝 1次赋值
//
//	return 0;
//}

//
////360笔试题
//Widget f(Widget u) {
//    Widget v(u);
//    Widget w = v;
//    return w;
//}
//main() {
//    Widget x;
//    Widget y = f(f(x));
//}